//============================================================================================
/**
 * @file	pkthln_push_sub.c
 * @brief	おしくらまんじゅうサブ画面
 * @author	Nozomu Saito
 *
 * モジュール名：PushSub_
 */
//============================================================================================
#include "pkthln_push_sub.h"

#include "system/softsprite.h"
#include "system/arc_tool.h"
#include "system/gra_tool.h"
#include "system/clact_util_vram.h"
#include "system/fontproc.h"
#include "system/msgdata_util.h"
#include "system/wordset.h"
#include "system/snd_tool.h"
#include "../event_se_def.h"
#include "poketool/poke_tool.h"

#include "../../../../field/field_cutin.naix"

#include "push_obj_pri.h"
#include "../pkthln_act_def.h"
#include "../../poke_clact.h"

#include "msgdata/msg.naix"
#include "msgdata/msg_pokethlon.h"

#include "pkthev_push.naix"

#define TRANS_POKE_NUM	(2)
#define TRNS_PALETTE_NUM	(1)

#define POKE_BG_PRI	(3)

#define POKE_MAX		(ENTRY_MAX*ENTRY_MEMBER_NUM_MAX)
#define WIN_MAX			(ENTRY_MEMBER_NUM_MAX+1)		//プレーヤー名4+ラウンド表示1

#define MSG_BG	(GF_BGL_FRAME0_S)
#define AFF_BG	(GF_BGL_FRAME3_S)
#define CMN_BG	(GF_BGL_FRAME2_S)

#define	PUSH_SYS_FONT_PAL	(15)
#define	BAGCOL_N_WHITE	( GF_PRINTCOLOR_MAKE( 15, 14, 0 ) )		// フォントカラー：白

#define NORMAL_DEMO_LOOP	(3)
#define RND_TRIAL_MAX		(10)

#define BATTLE_DEMO_FRAME	(50)
#define BATTLE_DEMO_FRAME1	(5)
#define BATTLE_DEMO_FRAME2	(40)
#define BATTLE_DEMO_FRAME3	(5)

#define FALL_DEMO_FRAME	(70)
#define FALL_DEMO_FRAME1	(15)
#define FALL_DEMO_FRAME2	(45)
#define FALL_DEMO_FRAME3	(10)

#define LOGO_DEMO_FRAME	(80)
#define LOGO_DEMO_FRAME1	(40)
#define LOGO_DEMO_FRAME2	(20)
#define LOGO_DEMO_FRAME3	(20)

#define SCORE_NUMBER_W	(4)		//得点用数字横キャラ幅
#define SCORE_NUMBER_H	(8)		//得点用数字縦キャラ幅
#define SCORE_DIGI_MAX	(3)		//得点は最大３桁
#define SCORE_DISP_START_X	(3)	//得点描画開始X位置（キャラ）
#define SCORE_DISP_START_Y	(7)	//得点描画開始Y位置（キャラ）
#define NUMBER_SCR_NUM_W	(5)	//数字スクリーンデータの横の数字の数0〜4	スクリーンデータに依存
#define NUMBER_SCR_NUM_H	(2)	//数字スクリーンデータの縦の数字の数5〜9	スクリーンデータに依存

#define FALL_POKE_POS_X	(128*FX32_ONE)

#define FALL_SPEED	(32)

#define LOGO_EFF_START_X	(56)	//ドット
#define LOGO_EFF_START_Y	(144)	//ドット
#define LOGO_EFF_MOVE_LEN	(144)	//ドット

#define BTL_ALPHA_BLEND_SYNC	(4)
#define ALPHA_WAIT_SYNC	(10)

typedef void (*PLAY_DEMO_FUNC)( SUB_DISP_CNT_PTR ptr );

typedef enum {
	DEMO_TYPE_NONE,
	DEMO_TYPE_SCORE,
	DEMO_TYPE_FALL,
	DEMO_TYPE_BATTLE,
	DEMO_TYPE_LOGO,
}DEMO_TYPE;

typedef struct POKE_GRA_tag
{
	void *PokeChar;
	void *PokePal;
}POKE_GRA;

typedef struct DEMO_CONT_tag
{
	BOOL DemoPlay;
	BOOL Pause;
	u8 Fall[POKE_MAX];
	PLAY_DEMO_FUNC PlayFunc;
	u16 NormDemoCount;
	u16 DemoFrame;
	DEMO_TYPE DemoType;

	u32 ImageVram[TRANS_POKE_NUM];
	u32 PaletteVram[TRANS_POKE_NUM];
	POKE_GRA	PokeGra[POKE_MAX];
	PKTHLN_ACT_PTR	ActPtr[TRANS_POKE_NUM];

	NNSG2dScreenData *LogoScrnData;
	NNSG2dScreenData *PokeBtlScrnData;
	NNSG2dScreenData *LogoBaseScrnData;
	NNSG2dScreenData *PointBaseScrnData;
	NNSG2dScreenData *BtlBaseScrnData;
	NNSG2dScreenData *FallBaseScrnData;
	NNSG2dScreenData *PointScrnData;

	PKTHLN_ACT_PTR	RoundActPtr;
	PKTHLN_ACT_PTR	RNumActPtr;
	PKTHLN_ACT_PTR	LightActPtr[2];
	PKTHLN_ACT_PTR	LogoEffActPtr;
	PKTHLN_ACT_PTR	FlagActPtr[ENTRY_MEMBER_NUM_MAX];
	PKTHLN_ACT_PTR	PointActPtr[ENTRY_MEMBER_NUM_MAX];

	u8 DispScore;
	u8 FilledScore;
	u8 BGOffset;
	u8 dummy;
}DEMO_CONT;

typedef struct SUB_DISP_CNT_tag
{
	int HeapID;
	PKTHLN_PTR PkthlnPtr;		//ポケスロンポインタ	これで、マイステータスとかにアクセスする

	GF_BGL_INI * Bgl;
	GF_BGL_BMPWIN	Win[WIN_MAX];			// BMPウィンドウデータ
	MSGDATA_MANAGER* MsgMan;
	WORDSET * Wset;
	int Round;						//無駄な書き換えをしないように、ラウンド数を記憶しておく

	DEMO_CONT DemoCnt;

	void *SubBaseBgArc[4];
	void *PointBgArc;
	void *AffineBgArc[2];

	u8 FlagNo[ENTRY_MEMBER_NUM_MAX];		//ネットＩＤとフラグ位置の対応配列

}SUB_DISP_CNT;

#define WIN_NAME1_PX	(6)
#define WIN_NAME1_PY	(16)
#define WIN_NAME2_PX	(21)
#define WIN_NAME2_PY	(8)
#define WIN_NAME3_PX	(21)
#define WIN_NAME3_PY	(12)
#define WIN_NAME4_PX	(21)
#define WIN_NAME4_PY	(16)
#define WIN_NAME_SX		(10)
#define WIN_NAME_SY		(2)
#define WIN_NAME_SIZE	( WIN_NAME_SX * WIN_NAME_SY )

#define WIN_ROUND_PX	(18)
#define WIN_ROUND_PY	(20)
#define WIN_ROUND_SX	(14)
#define WIN_ROUND_SY	(2)

#define FONT_PAL	(PUSH_SYS_FONT_PAL)
#define WIN_CGX_BASE	(1)
#define WIN_NAME1_CGX	(WIN_CGX_BASE)
#define WIN_NAME2_CGX	(WIN_NAME1_CGX + WIN_NAME_SIZE )
#define WIN_NAME3_CGX	(WIN_NAME2_CGX + WIN_NAME_SIZE )
#define WIN_NAME4_CGX	(WIN_NAME3_CGX + WIN_NAME_SIZE )
#define WIN_ROUND_CGX	(WIN_NAME4_CGX + WIN_NAME_SIZE )

static void ResetDemoParam(SUB_DISP_CNT_PTR ptr);
static void AttouchPokeVramAdr( PKTHLN_CLACT_CNT_PTR inPokeActPtr, SUB_DISP_CNT_PTR ptr );
static void CreateBmpWin( SUB_DISP_CNT_PTR ptr );
static void WriteRound( SUB_DISP_CNT_PTR ptr, const u8 inRound );

//デモ関連
static void SetPokeGra(SUB_DISP_CNT_PTR ptr);
static void TransPokeGra(DEMO_CONT *cnt_ptr, const u8 inTarget, const u8 inPoke);
static int GetFallingPoke(DEMO_CONT *cnt_ptr, const u8 *inFall);
static BOOL CheckDemoPriority(DEMO_CONT* cnt_ptr, const DEMO_TYPE inDemoType);
static void ClearDemo(DEMO_CONT *cnt_ptr);
static void VanishObj(DEMO_CONT *cnt_ptr);
static BOOL StopDemo(DEMO_CONT *cnt_ptr, const DEMO_TYPE inDemoType);
static void SetupScoreDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl);
static void SetupFallDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl, const u8 inIdx);
static void SetupBattleDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl);
static void SetupLogoDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl);
static void SetupNormalDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl);
static void PlayScoreDemo(SUB_DISP_CNT_PTR ptr);
static void PlayFallDemo(SUB_DISP_CNT_PTR ptr);
static void PlayBattleDemo(SUB_DISP_CNT_PTR ptr);
static void PlayLogoDemo(SUB_DISP_CNT_PTR ptr);
static void SetupBtlDemoPoke(DEMO_CONT *cnt_ptr);
static void SetBtlPokePos(const u8 inFrame, const VecFx32 *inPosList, PKTHLN_ACT_PTR actPtr);
static void SetupFallPoke(DEMO_CONT *cnt_ptr, const u8 inIdx);
static void SetFallPokePos(const u8 inFrame, const fx32 *inPosList, PKTHLN_ACT_PTR actPtr);
static void FillScore(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl);
static void ReMakeScreenData(const inOfs, NNSG2dScreenData *ioScrnData);

static DEMO_TYPE NormalDemoLoop[NORMAL_DEMO_LOOP] = {
	DEMO_TYPE_LOGO,
	DEMO_TYPE_BATTLE,
	DEMO_TYPE_BATTLE,
};

enum{
	ANM_ROUND = 0,
	ANM_R1,
	ANM_R2,
	ANM_R3,
	ANM_R4,
	ANM_R5,
	ANM_R6,
	ANM_R7,
	ANM_R8,
	ANM_LIGHT_L = 11,
	ANM_LIGHT_R,
	ANM_LOGO_EFF,
	ANM_FLG_RED,
	ANM_FLG_BL,
	ANM_FLG_YEL,
	ANM_FLG_GR,
	ANM_P1,
	ANM_P2,
	ANM_P5,
	ANM_P10,
};


static const BMPWIN_DAT PushEvtBmpData[] =
{

	{	// 0:トレーナー名
		MSG_BG, WIN_NAME1_PX, WIN_NAME1_PY,
		WIN_NAME_SX, WIN_NAME_SY, FONT_PAL, WIN_NAME1_CGX
	},
	{	// 1:トレーナー名
		MSG_BG, WIN_NAME2_PX, WIN_NAME2_PY,
		WIN_NAME_SX, WIN_NAME_SY, FONT_PAL, WIN_NAME2_CGX
	},
	{	// 2:トレーナー名
		MSG_BG, WIN_NAME3_PX, WIN_NAME3_PY,
		WIN_NAME_SX, WIN_NAME_SY, FONT_PAL, WIN_NAME3_CGX
	},
	{	// 3:トレーナー名
		MSG_BG, WIN_NAME4_PX, WIN_NAME4_PY,
		WIN_NAME_SX, WIN_NAME_SY, FONT_PAL, WIN_NAME4_CGX
	},
	{	// 4:ラウンド
		MSG_BG, WIN_ROUND_PX, WIN_ROUND_PY,
		WIN_ROUND_SX, WIN_ROUND_SY, FONT_PAL, WIN_ROUND_CGX
	},
};

//デモポケの座標
const VecFx32 BtlDemoPokePos1[] = {
	{ 296*FX32_ONE, 24*FX32_ONE, 0 },
	{ 168*FX32_ONE, 120*FX32_ONE, 0 },
	{ 176*FX32_ONE, 112*FX32_ONE, 0 },
	{ 104*FX32_ONE, -24*FX32_ONE, 0 },
};

const VecFx32 BtlDemoPokePos2[] = {
	{ 40*FX32_ONE, 232*FX32_ONE, 0 },
	{ 104*FX32_ONE, 136*FX32_ONE, 0 },
	{ 96*FX32_ONE, 136*FX32_ONE, 0 },
	{ 168*FX32_ONE, 272*FX32_ONE, 0 },
};

const fx32 FallDemoPokePos[] = {
	-40*FX32_ONE,
	120*FX32_ONE,
	296*FX32_ONE,
};


//----------------------------------------------------------------------------
/**
 *	@brief	初期化
 *
 *	@param	inHeapID	ヒープＩＤ
 *	@param	*inBgl		BGL
 *	@param	pkthlnPtr 	ポケスロンポインタ
 *
 *	@return	コントローラポインタ
 */
//-----------------------------------------------------------------------------
SUB_DISP_CNT_PTR PushSub_Init( const int inHeapID, GF_BGL_INI *inBgl, PKTHLN_PTR pkthlnPtr )
{
	SUB_DISP_CNT_PTR ptr;
	int size;
	size = sizeof(SUB_DISP_CNT);

	ptr = sys_AllocMemory( inHeapID, size );
	MI_CpuClear8( ptr, size);

	ptr->HeapID = inHeapID;

	ptr->Bgl = inBgl;

	ptr->PkthlnPtr = pkthlnPtr;

	//BMP
	CreateBmpWin(ptr);

	//メッセージマネージャ
	//アーカイブから展開して表示
    ptr->MsgMan = MSGMAN_Create(MSGMAN_TYPE_DIRECT, ARC_MSG, NARC_msg_pokethlon_dat, inHeapID);
	//ワードセット
	ptr->Wset = WORDSET_Create( inHeapID );

	return ptr;
}


//----------------------------------------------------------------------------
/**
 *	@brief	解放
 *
 *	@param	ptr	コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_Free(SUB_DISP_CNT_PTR ptr)
{
	int i;
	for(i=0;i<POKE_MAX;i++){
		sys_FreeMemoryEz( ptr->DemoCnt.PokeGra[i].PokeChar );
		sys_FreeMemoryEz( ptr->DemoCnt.PokeGra[i].PokePal );
	}

	//スクリーンアーカイブ解放
	for(i=0;i<4;i++){
		sys_FreeMemoryEz(ptr->SubBaseBgArc[i]);
	}
	sys_FreeMemoryEz(ptr->PointBgArc);
	for(i=0;i<2;i++){
		sys_FreeMemoryEz(ptr->AffineBgArc[i]);
	}

	//ワードセット
	WORDSET_Delete(ptr->Wset);
	//メッセージマネージャ
	MSGMAN_Delete(ptr->MsgMan);

	//BMP
	for(i=0;i<WIN_MAX;i++){
		GF_BGL_BmpWinDel( &ptr->Win[i] );
	}

	sys_FreeMemoryEz(ptr);
}

//----------------------------------------------------------------------------
/**
 *	@brief		スクリーンセット
 *
 *	@param	ptr	コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_SetScreen(SUB_DISP_CNT_PTR ptr)
{
	{
		void *arc;
		NNSG2dScreenData *scr_data;
		arc = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub01_nscr,
						FALSE, &scr_data, ptr->HeapID);
		GF_BGL_ScreenBufSet( ptr->Bgl, GF_BGL_FRAME1_S, scr_data->rawData, scr_data->szByte );
		GF_BGL_ScrPalChange( ptr->Bgl, GF_BGL_FRAME1_S, 0, 0, 32, 24, 2 );
		GF_BGL_LoadScreenV_Req(ptr->Bgl, GF_BGL_FRAME1_S);
		sys_FreeMemoryEz(arc);
	}

	//スクリーン
	ptr->AffineBgArc[0] = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_logo_nscr,
						FALSE, &ptr->DemoCnt.LogoScrnData, ptr->HeapID);
	ptr->AffineBgArc[1] = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_pokebattle_nscr,
						FALSE, &ptr->DemoCnt.PokeBtlScrnData, ptr->HeapID);

	GF_BGL_ScreenBufSet( ptr->Bgl, AFF_BG,
			ptr->DemoCnt.LogoScrnData->rawData, ptr->DemoCnt.LogoScrnData->szByte );
/**
	ArcUtil_ScrnSet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_logo_nscr,
						ptr->Bgl, LOGO_BG, 0, 0, FALSE, ptr->HeapID);
*/

	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG3, VISIBLE_OFF );

	ptr->SubBaseBgArc[0] = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_pointbase_nscr,
						FALSE, &ptr->DemoCnt.PointBaseScrnData, ptr->HeapID);
	ptr->SubBaseBgArc[1] = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_pokebatbase_nscr,
						FALSE, &ptr->DemoCnt.BtlBaseScrnData, ptr->HeapID);
	ptr->SubBaseBgArc[2] = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_logobase_nscr,
						FALSE, &ptr->DemoCnt.LogoBaseScrnData, ptr->HeapID);
	ptr->SubBaseBgArc[3] = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_pokemissbase_nscr,
						FALSE, &ptr->DemoCnt.FallBaseScrnData, ptr->HeapID);
	ptr->PointBgArc = ArcUtil_ScrnDataGet(ARC_PKTHEV_PUSH, NARC_pkthev_push_push_bg_sub02_point_nscr,
						FALSE, &ptr->DemoCnt.PointScrnData, ptr->HeapID);

	//オリジナルのスクリーンデータの書き換え（GF_BGL_FRAME1_Sで使用するキャラ分のオフセットを足しこむ）
	ReMakeScreenData(SUB_WIDE_SCREEN_CHAR_SIZE, ptr->DemoCnt.PointBaseScrnData);
	ReMakeScreenData(SUB_WIDE_SCREEN_CHAR_SIZE, ptr->DemoCnt.BtlBaseScrnData);
	ReMakeScreenData(SUB_WIDE_SCREEN_CHAR_SIZE, ptr->DemoCnt.FallBaseScrnData);
	ReMakeScreenData(SUB_WIDE_SCREEN_CHAR_SIZE, ptr->DemoCnt.LogoBaseScrnData);
	ReMakeScreenData(SUB_WIDE_SCREEN_CHAR_SIZE, ptr->DemoCnt.PointScrnData);

	GF_BGL_ScreenBufSet( ptr->Bgl, CMN_BG,
			ptr->DemoCnt.PointBaseScrnData->rawData, ptr->DemoCnt.PointBaseScrnData->szByte );

	FillScore(&ptr->DemoCnt, ptr->Bgl);

	GF_BGL_ScrPalChange( ptr->Bgl, CMN_BG, 0, 0, 32, 24, 3 );

	GF_BGL_LoadScreenV_Req(ptr->Bgl, CMN_BG);
}

//----------------------------------------------------------------------------
/**
 *	@brief		ポケモングラフィックセットアップ
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_SetupPokeGraphic(SUB_DISP_CNT_PTR ptr)
{
	SetPokeGra(ptr);
}

//----------------------------------------------------------------------------
/**
 *	@brief	ポケモン画像転送のためリソース周りの処理
 *
 *	@param	inPokeActPtr		アクターコントローラポインタ
 *	@param	ptr					コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_SetTrnsPokeRes(PKTHLN_CLACT_CNT_PTR inPokeActPtr, SUB_DISP_CNT_PTR ptr)
{
	int i;
	int res_code[TRANS_POKE_NUM] = {RES_CODE_TRNS_POKE1, RES_CODE_TRNS_POKE2};
	for(i=0;i<TRANS_POKE_NUM;i++){
		PkthlnClAct_SetChar( inPokeActPtr,
							ARC_FIELD_CUTIN_GRA, NARC_field_cutin_poke_oam_NCGR,
							res_code[i], NNS_G2D_VRAM_TYPE_2DSUB);
		PkthlnClAct_SetPaltt( inPokeActPtr,
							ARC_FIELD_CUTIN_GRA, NARC_field_cutin_dp_boy01_NCLR,
							res_code[i], NNS_G2D_VRAM_TYPE_2DSUB, TRNS_PALETTE_NUM	);
		PkthlnClAct_SetCell( inPokeActPtr,
							ARC_FIELD_CUTIN_GRA, NARC_field_cutin_poke_oam_NCER, res_code[i]	);
		PkthlnClAct_SetAnm(	inPokeActPtr,
							ARC_FIELD_CUTIN_GRA, NARC_field_cutin_poke_oam_NCER, res_code[i]	);
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief	ポケモンセット
 *
 *	@param	inActCntPtr	アクターコントローラポインタ
 *	@param	ptr			コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_SetPoke(PKTHLN_CLACT_CNT_PTR inActCntPtr, SUB_DISP_CNT_PTR ptr)
{
	int i;
	int res_code[TRANS_POKE_NUM] = {RES_CODE_TRNS_POKE1, RES_CODE_TRNS_POKE2};
	int act_code[TRANS_POKE_NUM] = {ACT_CODE_TRNS_POKE1, ACT_CODE_TRNS_POKE2};
	for(i=0;i<TRANS_POKE_NUM;i++){
		PkthlnClAct_SetActor(inActCntPtr, POKE_BG_PRI, NNS_G2D_VRAM_TYPE_2DSUB, res_code[i], act_code[i]);
	}
	for(i=0;i<TRANS_POKE_NUM;i++){
		CLACT_WORK_PTR act_ptr;
		ptr->DemoCnt.ActPtr[i] =
			PkthlnClAct_GetActPtr(inActCntPtr, res_code[i], act_code[i]);
		act_ptr = PkthlnClAct_GetClActWorkPtr(ptr->DemoCnt.ActPtr[i]);
		//プライオリティセット
		CLACT_DrawPriorityChg( act_ptr, PRI_TRNS_POKE );
		{
			VecFx32 vec;
			vec.z = 0;
			vec.x = (64 + (128*i)) * FX32_ONE;
			vec.y = SUB_DISP_DISTANCE+(96*FX32_ONE);
			CLACT_SetMatrix( act_ptr, &vec );
		}
		PkthlnClAct_SetActive(ptr->DemoCnt.ActPtr[i], 1, 0);	//不可視でセット
	}

	AttouchPokeVramAdr( inActCntPtr, ptr );
}

//----------------------------------------------------------------------------
/**
 *	@brief	ポケモン以外のＯＢＪセット
 *
 *	@param	inActCntPtr	アクターコントローラポインタ
 *	@param	ptr			コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_SetObj(PKTHLN_CLACT_CNT_PTR inActCntPtr, SUB_DISP_CNT_PTR ptr)
{
	DEMO_CONT	*cnt;
	u8 i;
	CLACT_WORK_PTR act_ptr;
	VecFx32 vec = {0,0,0};
	u8 fp_pos_x[ENTRY_MEMBER_NUM_MAX] = {32,152,152,152};
	u8 fp_pos_y[ENTRY_MEMBER_NUM_MAX] = {136,72,104,136};

	cnt = &ptr->DemoCnt;
	//ラウンド
	PkthlnClAct_SetActor(inActCntPtr, 0, NNS_G2D_VRAM_TYPE_2DSUB, RES_CODE_PSUB_OBJ, ACT_CODE_ROUND);
	//数字
	PkthlnClAct_SetActor(inActCntPtr, 0, NNS_G2D_VRAM_TYPE_2DSUB, RES_CODE_PSUB_OBJ, ACT_CODE_RNUM);
	//ロゴエフェクト
	PkthlnClAct_SetActor(inActCntPtr, 1, NNS_G2D_VRAM_TYPE_2DSUB, RES_CODE_PSUB_OBJ, ACT_CODE_LOGO_EFF);
	//ライト
	for(i=0;i<2;i++){
		PkthlnClAct_SetActor(inActCntPtr, 0, NNS_G2D_VRAM_TYPE_2DSUB, RES_CODE_PSUB_OBJ, ACT_CODE_LIGHT);
	}
	//旗
	for(i=0;i<ENTRY_MEMBER_NUM_MAX;i++){
		PkthlnClAct_SetActor(inActCntPtr, 1, NNS_G2D_VRAM_TYPE_2DSUB, RES_CODE_PSUB_OBJ, ACT_CODE_SFLAG);
	}
	//ポイント
	for(i=0;i<ENTRY_MEMBER_NUM_MAX;i++){
		PkthlnClAct_SetActor(inActCntPtr, 1, NNS_G2D_VRAM_TYPE_2DSUB, RES_CODE_PSUB_OBJ, ACT_CODE_SPOINT);
	}


	//ラウンド
	cnt->RoundActPtr =
					PkthlnClAct_GetActPtr(inActCntPtr, RES_CODE_PSUB_OBJ, ACT_CODE_ROUND);
	act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->RoundActPtr);
	CLACT_DrawPriorityChg( act_ptr, PRI_ROUND );	//プライオリティセット
	CLACT_AnmChg( act_ptr, ANM_ROUND );
	//座標セット
	vec.x = 128 * FX32_ONE;
	vec.y = 32 * FX32_ONE + SUB_DISP_DISTANCE;
	CLACT_SetMatrix(act_ptr, &vec);
	PkthlnClAct_SetActive(cnt->RoundActPtr, TRUE, TRUE);		//表示

	//数字
	cnt->RNumActPtr =
					PkthlnClAct_GetActPtr(inActCntPtr, RES_CODE_PSUB_OBJ, ACT_CODE_RNUM);
	act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->RNumActPtr);
	CLACT_DrawPriorityChg( act_ptr, PRI_RNUM );	//プライオリティセット
	CLACT_AnmChg( act_ptr, ANM_R1 );
	//座標セット
	vec.x = 152 * FX32_ONE;
	vec.y = 32 * FX32_ONE + SUB_DISP_DISTANCE;
	CLACT_SetMatrix(act_ptr, &vec);
	PkthlnClAct_SetActive(cnt->RNumActPtr, TRUE, TRUE);		//表示

	//ロゴエフェクト
	cnt->LogoEffActPtr =
					PkthlnClAct_GetActPtr(inActCntPtr, RES_CODE_PSUB_OBJ, ACT_CODE_LOGO_EFF);
	act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->LogoEffActPtr);
	CLACT_DrawPriorityChg( act_ptr, PRI_LOGO_EFF );	//プライオリティセット
	CLACT_AnmChg( act_ptr, ANM_LOGO_EFF );
	//座標セット
	vec.x = 0 * FX32_ONE;
	vec.y = 0 * FX32_ONE + SUB_DISP_DISTANCE;
	CLACT_SetMatrix(act_ptr, &vec);
	PkthlnClAct_SetActive(cnt->LogoEffActPtr, TRUE, FALSE);		//非表示

	//ライト
	for(i=0;i<2;i++){
		cnt->LightActPtr[i] =
						PkthlnClAct_GetActPtr(inActCntPtr, RES_CODE_PSUB_OBJ, ACT_CODE_LIGHT);
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->LightActPtr[i]);
		CLACT_DrawPriorityChg( act_ptr, PRI_LIGHT );	//プライオリティセット
		CLACT_AnmChg( act_ptr, ANM_LIGHT_L+i );
		//座標セット
		vec.x = (48+160*i) * FX32_ONE;
		vec.y = 24 * FX32_ONE + SUB_DISP_DISTANCE;
		CLACT_SetMatrix(act_ptr, &vec);
		PkthlnClAct_SetActive(cnt->LightActPtr[i], TRUE, TRUE);		//表示
	}

	//旗
	for(i=0;i<ENTRY_MEMBER_NUM_MAX;i++){
		cnt->FlagActPtr[i] =
					PkthlnClAct_GetActPtr(inActCntPtr, RES_CODE_PSUB_OBJ, ACT_CODE_SFLAG);
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->FlagActPtr[i]);
		CLACT_DrawPriorityChg( act_ptr, PRI_SFLAG );	//プライオリティセット
		CLACT_AnmChg( act_ptr, ANM_FLG_RED );
		//座標セット
		vec.x = fp_pos_x[i] * FX32_ONE;
		vec.y = fp_pos_y[i] * FX32_ONE + SUB_DISP_DISTANCE;
		CLACT_SetMatrix(act_ptr, &vec);
		PkthlnClAct_SetActive(cnt->FlagActPtr[i], TRUE, TRUE);		//表示
	}
	//ポイント
	for(i=0;i<ENTRY_MEMBER_NUM_MAX;i++){
		cnt->PointActPtr[i] =
					PkthlnClAct_GetActPtr(inActCntPtr, RES_CODE_PSUB_OBJ, ACT_CODE_SPOINT);
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->PointActPtr[i]);
		CLACT_DrawPriorityChg( act_ptr, PRI_SPOINT );	//プライオリティセット
		CLACT_AnmChg( act_ptr, ANM_P1 );
		//座標セット
		vec.x = fp_pos_x[i] * FX32_ONE;
		vec.y = fp_pos_y[i] * FX32_ONE + SUB_DISP_DISTANCE;
		CLACT_SetMatrix(act_ptr, &vec);
		PkthlnClAct_SetActive(cnt->PointActPtr[i], TRUE, FALSE);	//非表示
	}
}

//--------------------------------------------------------------------------------------------
/**
 * 情報表示
 *
 * @param	ptr		管理ポインタ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
void PushSub_WriteWinInfo( SUB_DISP_CNT_PTR ptr )
{
	u8 i;

	for(i=0;i<WIN_MAX;i++){
		GF_BGL_BmpWinDataFill( &ptr->Win[i], 0);
	}

	//名前
	{
		CLACT_WORK_PTR act_ptr;
		u8 win_cnt;
		u8 my_id;
		//第一枠は必ず自分の名前
		STRBUF *name_buf;

		my_id = PTFrameGetCurrentID(ptr->PkthlnPtr);
		//マイステータスにアクセスして名前取得
		name_buf = MyStatus_CreateNameString(
				PTFrame_GetMyStatus(ptr->PkthlnPtr, my_id),
				ptr->HeapID);
		GF_STR_PrintColor( 	&ptr->Win[0], FONT_SYSTEM, name_buf,
				0, 0, MSG_NO_PUT, BAGCOL_N_WHITE, NULL );
		STRBUF_Delete(name_buf);

		//フラッグ色決定
		act_ptr = PkthlnClAct_GetClActWorkPtr(ptr->DemoCnt.FlagActPtr[0]);
		CLACT_AnmChg( act_ptr, ANM_FLG_RED+my_id );

		//ネットＩＤとフラグナンバーを対応させる
		ptr->FlagNo[my_id] = 0;

		win_cnt = 1;
		//２枠からは他プレーヤー
		for (i=0; i<ENTRY_MEMBER_NUM_MAX; i++){
			STRBUF *name_buf;
			if (i==my_id){
				continue;
			}
			//マイステータスにアクセスして名前取得
			name_buf = MyStatus_CreateNameString(
					PTFrame_GetMyStatus(ptr->PkthlnPtr, i),
					ptr->HeapID);
			GF_STR_PrintColor( 	&ptr->Win[win_cnt], FONT_SYSTEM, name_buf,
					0, 0, MSG_NO_PUT, BAGCOL_N_WHITE, NULL );
			STRBUF_Delete(name_buf);

			//フラッグ色決定
			act_ptr = PkthlnClAct_GetClActWorkPtr(ptr->DemoCnt.FlagActPtr[win_cnt]);
			CLACT_AnmChg( act_ptr, ANM_FLG_RED+i );
			//ネットＩＤとフラグナンバーを対応させる
			ptr->FlagNo[i] = win_cnt;
			win_cnt++;
		}
	}

	//ラウンド
	WriteRound( ptr, 1 );

	for(i=0;i<WIN_MAX;i++){
		GF_BGL_BmpWinOn(&ptr->Win[i]);
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief		ラウンド更新
 *
 *	@param	ptr		コントローラポインタ
 *	@param	inRound	ラウンド
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_UpdateRoundDisp(SUB_DISP_CNT_PTR ptr, const u8 inRound)
{
	if (ptr->Round == inRound){
		return;
	}
	ptr->Round = inRound;
	WriteRound( ptr, inRound );
	//ＯＢＪのラウンド数を書き換え
	{
		CLACT_WORK_PTR act_ptr;
		act_ptr = PkthlnClAct_GetClActWorkPtr(ptr->DemoCnt.RNumActPtr);
		CLACT_AnmChg( act_ptr, ANM_R1+inRound-1 );
	}

	GF_BGL_BmpWinOn(&ptr->Win[WIN_MAX-1]);
}

//----------------------------------------------------------------------------
/**
 *	@brief	得点加算エフェクト開始
 *
 *	@param	ptr			コントローラポインタ
 *	@param	inNetID		ネットＩＤ
 *	@param	inScoreNo	ポイントナンバー
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_StartPointEff(SUB_DISP_CNT_PTR ptr, const u8 inNetID, const u8 inScoreNo)
{
	u8 anm;
	u8 idx;
	CLACT_WORK_PTR act_ptr;
	switch(inScoreNo){
	case 1:
		anm = ANM_P1;
		break;
	case 2:
		anm = ANM_P2;
		break;
	case 3:
		anm = ANM_P5;
		break;
	case 4:
		anm = ANM_P10;
		break;
	default:
		OS_Printf("score_no=%d\n",inScoreNo);
		GF_ASSERT(0);
		anm = ANM_P1;
	}
	idx = ptr->FlagNo[inNetID];

	PkthlnClAct_SetActive(ptr->DemoCnt.PointActPtr[idx], TRUE, TRUE);	//表示
	act_ptr = PkthlnClAct_GetClActWorkPtr(ptr->DemoCnt.PointActPtr[idx]);
	CLACT_AnmChg( act_ptr, anm );
}

//----------------------------------------------------------------------------
/**
 *	@brief		デモの状況リセット(1ラウンド終了したら、コール)
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void ResetDemoParam(SUB_DISP_CNT_PTR ptr)
{
	u8 i;
	for(i=0;i<POKE_MAX;i++){
		ptr->DemoCnt.Fall[i] = 0;
	}

	ptr->DemoCnt.Pause = 0;
	ClearDemo(&ptr->DemoCnt);
}


//----------------------------------------------------------------------------
/**
 *	@brief	ＶＲＡＭアドレス割り当て
 *
 *	@param	inActPtr		アクターコントローラポインタ
 *	@param	ptr 				コントローラポインタ
 *
 *	@return
 */
//-----------------------------------------------------------------------------
static void AttouchPokeVramAdr( PKTHLN_CLACT_CNT_PTR inActPtr, SUB_DISP_CNT_PTR ptr )
{
	CLACT_U_RES_OBJ_PTR res_obj_ptr;
	CLACT_U_RES_OBJ_PTR res_pal_ptr;
	NNSG2dImageProxy *image_proxy;
	const NNSG2dImagePaletteProxy *palette_proxy;

	u8 i;
	int res_code[TRANS_POKE_NUM] = {RES_CODE_TRNS_POKE1, RES_CODE_TRNS_POKE2};

	for(i=0;i<TRANS_POKE_NUM;i++){
		res_obj_ptr = *PkthlnClAct_GetResObjPtrAdr( inActPtr, res_code[i] , CLACT_U_CHAR_RES );
		res_pal_ptr = *PkthlnClAct_GetResObjPtrAdr( inActPtr, res_code[i] , CLACT_U_PLTT_RES );
		image_proxy = CLACT_U_CharManagerGetProxy( res_obj_ptr );
		palette_proxy = CLACT_U_PlttManagerGetProxy( res_pal_ptr, image_proxy );

		ptr->DemoCnt.ImageVram[i] = NNS_G2dGetImageLocation( image_proxy, NNS_G2D_VRAM_TYPE_2DSUB );
		ptr->DemoCnt.PaletteVram[i] = NNS_G2dGetImagePaletteLocation( palette_proxy, NNS_G2D_VRAM_TYPE_2DSUB );
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief		ポケグラフィックセット
 *
 *	@param	ptr	コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetPokeGra(SUB_DISP_CNT_PTR ptr)
{
	int i;
	SOFT_SPRITE_ARC sprite;
	//最後の引数は、FormNoと個性乱数です by soga 2006.05.01

	for(i=0;i<POKE_MAX;i++){
		MONS_INFO info;
		PTFrame_SetMonsInfo(ptr->PkthlnPtr, i/ENTRY_MAX, i%ENTRY_MAX, &info);
		PokeGraArcDataGet( &sprite, info.MonsNo, info.Sex, PARA_FRONT, info.Rare, info.Form, info.PsnlRnd );
		ptr->DemoCnt.PokeGra[i].PokeChar =
			Ex_ChangesInto_BattlePokeData_Alloc(sprite.arc_no, sprite.index_chr, ptr->HeapID,
				info.PsnlRnd, FALSE, PARA_FRONT, info.MonsNo);
		ptr->DemoCnt.PokeGra[i].PokePal =
			ChangesInto_BattlePokePalData_Alloc( sprite.arc_no, sprite.index_pal, ptr->HeapID);
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief		ポケグラフィック転送
 *
 *	@param	*cnt_ptr		デモコントローラ
 *	@param	inTarget		転送ターゲットポケ
 *	@param	inPoke			ポケインデックス
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void TransPokeGra(DEMO_CONT *cnt_ptr, const u8 inTarget, const u8 inPoke)
{
	int chr_trans_size;
	int plt_trans_size;

	GF_ASSERT(inTarget < TRANS_POKE_NUM);
	GF_ASSERT(inPoke < POKE_MAX);

	chr_trans_size = (32*10)*10;	//32byte x10 y10
	plt_trans_size = 32;	//32byte

	DC_FlushRange(cnt_ptr->PokeGra[inPoke].PokeChar,chr_trans_size);
	GXS_LoadOBJ( cnt_ptr->PokeGra[inPoke].PokeChar, cnt_ptr->ImageVram[inTarget], chr_trans_size );

	DC_FlushRange( cnt_ptr->PokeGra[inPoke].PokePal, plt_trans_size );
	GXS_LoadOBJPltt( cnt_ptr->PokeGra[inPoke].PokePal, cnt_ptr->PaletteVram[inTarget], plt_trans_size );	//32byte 1Palette

}


//--------------------------------------------------------------------------------------------
/**
 * BMPウィンドウ追加
 *
 * @param 	ptr			コントローラポインタ
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
static void CreateBmpWin( SUB_DISP_CNT_PTR ptr )
{
	u8 i;
	const BMPWIN_DAT * dat = PushEvtBmpData;
	for(i=0;i<WIN_MAX;i++){
		GF_BGL_BmpWinAddEx( ptr->Bgl, &(ptr->Win[i]), &dat[i] );
	}

	//先頭キャラをクリア（スクリーンクリアされてるところは、このキャラで埋まる）
	GF_BGL_CharFill( ptr->Bgl, MSG_BG, 0, 1, 0 );

	//会話ウィンドウ用リソース展開
///	TalkWinGraphicSet(bgl,MSG_BG,
///		TALKWIN_CGX, TALKWIN_PAL, wk->win_type, inHeapID);
	//システム用フォントパレット転送
	SystemFontPaletteLoad(PALTYPE_SUB_BG, PUSH_SYS_FONT_PAL*32, ptr->HeapID);
}

//--------------------------------------------------------------------------------------------
/**
 * ラウンド表示
 *
 * @param	ptr		管理ポインタ
 * @param	inRound	表示ラウンド
 *
 * @return	none
 */
//--------------------------------------------------------------------------------------------
static void WriteRound( SUB_DISP_CNT_PTR ptr, const u8 inRound )
{
	STRBUF * str;
	GF_BGL_BmpWinDataFill( &ptr->Win[WIN_MAX-1], 0);

	WORDSET_RegisterNumber(ptr->Wset, 0, inRound, 2,
				NUMBER_DISPTYPE_LEFT,NUMBER_CODETYPE_DEFAULT);
    str = MSGDAT_UTIL_AllocExpandString(ptr->Wset, ptr->MsgMan, msg_pkthln_push_round, ptr->HeapID);
	GF_STR_PrintColor( 	&ptr->Win[WIN_MAX-1], FONT_SYSTEM, str,
					0, 0, MSG_NO_PUT, BAGCOL_N_WHITE, NULL );

	STRBUF_Delete(str);//<一括表示なので、メモリをここで消してもOK
}


//----------------------------------------------------------------------------
/**
 *	@brief	ディスプレイメイン

 *
 *	@param	ptr			コントローラポインタ
 *	@param	inPause		ポーズ
 *	@param	*inFallList	落下ポケリスト
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_PlayDemoMain(SUB_DISP_CNT_PTR ptr, const BOOL inPause, const u8 *inFallList)
{
	DEMO_CONT	*cnt;
	u8 fall_idx;

	cnt = &ptr->DemoCnt;

	fall_idx = GetFallingPoke(cnt, inFallList);

	if (inPause == 0){
		//ポーズ解除初検出か？
		if (cnt->Pause){
			ResetDemoParam(ptr);
		}
	}

	//デモ割り込みチェック
	if (cnt->DemoPlay){	//再生中
		BOOL rc;
		OS_Printf("%dを再生中\n",cnt->DemoType);
		//ゲームポーズ中か？
		if (inPause){	//ポーズ中
			//ポーズ初検出か？
			if (!cnt->Pause){
				//ポーズフラグをセット
				cnt->Pause = 1;
				//現在のデモを中止
				rc = StopDemo(cnt, DEMO_TYPE_SCORE);
				GF_ASSERT(rc == TRUE);		//得点デモは最優先なので、FALSEが帰ってくることはないはず
				//スコアデモをセットアップ
				SetupScoreDemo(cnt, ptr->Bgl);
			}
		}else {
			if( fall_idx != POKE_MAX ){ //誰か落ちたか？
				//現在のデモ中止
				rc = StopDemo(cnt, DEMO_TYPE_FALL);
				if (rc){
					//落下デモをセットアップ
					Snd_SePlay(SE_PUSH_FALL);		//落下音
					SetupFallDemo(cnt, ptr->Bgl, fall_idx);
				}
			}
		}
	}else{
		//通常デモ(ロゴORバトル)をセットアップ
		SetupNormalDemo(cnt, ptr->Bgl);
	}

	//デモ再生
	if (cnt->PlayFunc != NULL){
		cnt->PlayFunc(ptr);
	}else{
		GF_ASSERT(0);
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief	得点書き換えメイン
 *
 *	@param	ptr		コントローラポインタ
 *	@param	inScore	スコア
 *	@param	inNetID　ネットＩＤ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
void PushSub_ScoreUpdate(SUB_DISP_CNT_PTR ptr, u8 inScore, u8 inNetID)
{
	//受け取ったデータは自分の得点かをチェック
	if (inNetID != PTFrameGetCurrentID(ptr->PkthlnPtr)){
		//自分の得点ではないので、処理終了
		return;
	}

	//現在表示している得点と差異があるか
	if (ptr->DemoCnt.DispScore != inScore){
		GF_ASSERT(ptr->DemoCnt.DispScore < inScore);	//違うならば、更新データのほうが大きいはず
		//書き換え
		ptr->DemoCnt.DispScore = inScore;
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief	表示得点取得
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	score	スコア
 */
//-----------------------------------------------------------------------------
u8 PushSub_GetDispScore(SUB_DISP_CNT_PTR ptr)
{
	return 	ptr->DemoCnt.DispScore;
}

//----------------------------------------------------------------------------
/**
 *	@brief	ポケ落下状況取得
 *
 *	@param	*cnt_ptr	コントローラポインタ
 *	@param	*inFall		落下ポケリスト
 *
 *	@return
 */
//-----------------------------------------------------------------------------
static int GetFallingPoke(DEMO_CONT *cnt_ptr, const u8 *inFall)
{
	int i;
	u8 fall[POKE_MAX];
	for(i=0;i<POKE_MAX;i++){
		if ( (inFall[i])&&(!cnt_ptr->Fall[i]) ){
			//落下フラグセット
			cnt_ptr->Fall[i] = 1;
			fall[i] = 1;
		}else{
			fall[i] = 0;
		}
	}
	//はじめに見つかったポケにしとく
	for(i=0;i<POKE_MAX;i++){
		if ( fall[i] ){
			return i;
		}
	}

	return POKE_MAX;
}

//
//----------------------------------------------------------------------------
/**
 *	@brief	デモ優先順位チェック
 *
 *	@param	cnt_ptr		コントローラポインタ
 *	@param	inDemoType	デモタイプ
 *
 *	@return	BOOL		指定デモが現在デモより優先順位が高ければTRUEを返す
 */
//-----------------------------------------------------------------------------
static BOOL CheckDemoPriority(DEMO_CONT* cnt_ptr, const DEMO_TYPE inDemoType)
{
	//再生中のデモと同じタイプの場合はFALSE
	if (cnt_ptr->DemoType == inDemoType){
		OS_Printf("同じデモタイプなので、割り込みなし\n");
		return FALSE;
	}else{
		if (inDemoType == DEMO_TYPE_SCORE){
			return TRUE;
		}else if( inDemoType == DEMO_TYPE_FALL ){
			if (cnt_ptr->DemoType != DEMO_TYPE_SCORE){
				return TRUE;
			}
		}
	}
	return FALSE;
}

//----------------------------------------------------------------------------
/**
 *	@brief		デモクリア
 *
 *	@param	*cnt_ptr		コントロールポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void ClearDemo(DEMO_CONT *cnt_ptr)
{
	int i;
	cnt_ptr->DemoPlay = FALSE;
	//デモフレームカウンタクリア
	cnt_ptr->DemoFrame = 0;
	//ポケバニッシュ
	for(i=0;i<TRANS_POKE_NUM;i++){
		PkthlnClAct_SetActive(cnt_ptr->ActPtr[i], 1, 0);
	}
	//ブレンドクリア
	G2S_BlendNone();
	//エフェクトアクターバニッシュ
	VanishObj(cnt_ptr);
	//アフィンBG非表示
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG3, VISIBLE_OFF );
	//フォントBG非表示
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG0, VISIBLE_OFF );
	//デモ再生関数にNULLセット
	cnt_ptr->PlayFunc = NULL;
	//スクロールオフセットクリア
	cnt_ptr->BGOffset = 0;
	G2S_SetBG2Offset(0, cnt_ptr->BGOffset);
}

//----------------------------------------------------------------------------
/**
 *	@brief		ＯＢＪのバニッシュ
 *
 *	@param	*cnt_ptr	コントローラポインタ
 *
 *	@return		none
 */
//-----------------------------------------------------------------------------
static void VanishObj(DEMO_CONT *cnt_ptr)
{
	u8 i;
	//ライト消す
	for(i=0;i<2;i++){
		PkthlnClAct_SetActive(cnt_ptr->LightActPtr[i], TRUE, FALSE);
	}
	//旗・ポイント消す
	for(i=0;i<ENTRY_MEMBER_NUM_MAX;i++){
		PkthlnClAct_SetActive(cnt_ptr->FlagActPtr[i], TRUE, FALSE);
		PkthlnClAct_SetActive(cnt_ptr->PointActPtr[i], TRUE, FALSE);
	}
	//ロゴエフェクト消す
	PkthlnClAct_SetActive(cnt_ptr->LogoEffActPtr, TRUE, FALSE);
}

//----------------------------------------------------------------------------
/**
 *	@brief	デモ中止処理
 *
 *	@param	*cnt_ptr	コントローラポインタ
 *	@param	inDemoType	デモタイプ
 *
 *	@return	BOOL
 *
 *	現在再生しようとしているデモと現在のデモを比較して、優先順位が高ければ、デモを中断し、TRUEを返す
 *	優先順位が低ければ、中断せず、FALSEを返す
 */
//-----------------------------------------------------------------------------
static BOOL StopDemo(DEMO_CONT *cnt_ptr, const DEMO_TYPE inDemoType)
{
	//現在のデモが指定デモより優先順位が低ければ、中断。
	if ( CheckDemoPriority(cnt_ptr, inDemoType) ){
		ClearDemo(cnt_ptr);
		return TRUE;
	}
	return FALSE;
}


//----------------------------------------------------------------------------
/**
 *	@brief		スコアデモ生成
 *
 *	@param	*cnt_ptr		コントローラポインタ
 *	@param	* inBgl			BGL
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetupScoreDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl)
{
	//フォントBG面表示
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG0, VISIBLE_ON );
	//必要ＯＢＪ表示
	{
		u8 i;
		//ライト
		for(i=0;i<2;i++){
			PkthlnClAct_SetActive(cnt_ptr->LightActPtr[i], TRUE, TRUE);
		}
		//旗
		for(i=0;i<ENTRY_MEMBER_NUM_MAX;i++){
			PkthlnClAct_SetActive(cnt_ptr->FlagActPtr[i], TRUE, TRUE);
		}
	}
	//得点BGスクリーンバッファをデモ共有BGに転送
	GF_BGL_ScreenBufSet( inBgl, CMN_BG,
			cnt_ptr->PointBaseScrnData->rawData, cnt_ptr->PointBaseScrnData->szByte );
	FillScore(cnt_ptr, inBgl);
	GF_BGL_ScrPalChange( inBgl, CMN_BG, 0, 0, 32, 24, 3 );
	GF_BGL_LoadScreenV_Req(inBgl, CMN_BG);
	//デモ再生関数セット
	cnt_ptr->PlayFunc = PlayScoreDemo;
	//デモタイプをスコアにする
	cnt_ptr->DemoType = DEMO_TYPE_SCORE;
	//デモ再生中にする
	cnt_ptr->DemoPlay = TRUE;
}

//----------------------------------------------------------------------------
/**
 *	@brief		落下デモ生成
 *
 *	@param	*cnt_ptr		コントローラポインタ
 *	@param	* inBgl			BGL
 *	@param	inIdx			落下ポケインデックス
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetupFallDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl, const u8 inIdx)
{
	//落下ポケ準備・初期位置セット
	SetupFallPoke(cnt_ptr, inIdx);
	//落下BGスクリーンバッファをデモ共有BGに転送
	GF_BGL_ScreenBufSet( inBgl, CMN_BG,
			cnt_ptr->FallBaseScrnData->rawData, cnt_ptr->FallBaseScrnData->szByte );
	GF_BGL_ScrPalChange( inBgl, CMN_BG, 0, 0, 32, 32, 3 );
	GF_BGL_LoadScreenV_Req(inBgl, CMN_BG);
	//デモ再生関数セット
	cnt_ptr->PlayFunc = PlayFallDemo;
	//デモタイプを落下にする
	cnt_ptr->DemoType = DEMO_TYPE_FALL;
	//デモ再生中にする
	cnt_ptr->DemoPlay = TRUE;

}

//----------------------------------------------------------------------------
/**
 *	@brief		バトルデモ生成
 *
 *	@param	*cnt_ptr		コントローラポインタ
 *	@param	* inBgl			BGL
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------

static void SetupBattleDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI *inBgl)
{
	//戦闘ポケ抽選・初期位置セット
	SetupBtlDemoPoke(cnt_ptr);

	//アフィンクリア
	{
		MtxFx22 mtx;
		mtx._00 = FX32_ONE;
		mtx._01 = 0;
		mtx._10 = 0;
		mtx._11 = FX32_ONE;

		SVC_WaitVBlankIntr();          // Waiting the end of VBlank interrup
		GF_BGL_AffineSet( inBgl, AFF_BG, &mtx, 128, 96 );
	}
	//戦闘BGスクリーンバッファをデモ共有BGに転送
	GF_BGL_ScreenBufSet( inBgl, CMN_BG,
			cnt_ptr->BtlBaseScrnData->rawData, cnt_ptr->BtlBaseScrnData->szByte );
	GF_BGL_ScrPalChange( inBgl, CMN_BG, 0, 0, 32, 24, 3 );
	GF_BGL_LoadScreenV_Req(inBgl, CMN_BG);
	//アフィンBGスクリーンバッファをデモ共有BGに転送
	GF_BGL_ScreenBufSet( inBgl, AFF_BG,
			cnt_ptr->PokeBtlScrnData->rawData, cnt_ptr->PokeBtlScrnData->szByte );
	GF_BGL_LoadScreenV_Req(inBgl, AFF_BG);
	//デモ再生関数セット
	cnt_ptr->PlayFunc = PlayBattleDemo;
	//デモタイプをバトルにする
	cnt_ptr->DemoType = DEMO_TYPE_BATTLE;
	//デモ再生中にする
	cnt_ptr->DemoPlay = TRUE;

}

//----------------------------------------------------------------------------
/**
 *	@brief		ロゴデモ生成
 *
 *	@param	*cnt_ptr		コントローラポインタ
 *	@param	* inBgl			BGL
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetupLogoDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl)
{
	//エフェクトアクター初期位置セット
	{
		CLACT_WORK_PTR act_ptr;
		VecFx32 vec = {0,0,0};
		vec.x = LOGO_EFF_START_X * FX32_ONE;
		vec.y = LOGO_EFF_START_Y * FX32_ONE + SUB_DISP_DISTANCE;
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt_ptr->LogoEffActPtr);
		CLACT_SetMatrix(act_ptr, &vec);
	}
	//ロゴBGスクリーンバッファをデモ共有BGに転送
	GF_BGL_ScreenBufSet( inBgl, CMN_BG,
			cnt_ptr->LogoBaseScrnData->rawData, cnt_ptr->BtlBaseScrnData->szByte );
	GF_BGL_ScrPalChange( inBgl, CMN_BG, 0, 0, 32, 24, 3 );
	GF_BGL_LoadScreenV_Req(inBgl, CMN_BG);
	//アフィンBGスクリーンバッファをデモ共有BGに転送
	GF_BGL_ScreenBufSet( inBgl, AFF_BG,
			cnt_ptr->LogoScrnData->rawData, cnt_ptr->LogoScrnData->szByte );
	GF_BGL_LoadScreenV_Req(inBgl, AFF_BG);
	//アフィン設定
	{
		MtxFx22 mtx;
		fx32 scale;
		float val;

		val = 1.0/LOGO_DEMO_FRAME1;

		scale = FX32_ONE * val;
		mtx._00 = scale;
		mtx._01 = 0;
		mtx._10 = 0;
		mtx._11 = scale;

		SVC_WaitVBlankIntr();          // Waiting the end of VBlank interrup
		GF_BGL_AffineSet( inBgl, AFF_BG, &mtx, 128, 96 );
	}
	//アフィンBG表示
	GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG3, VISIBLE_ON );
	//デモ再生関数セット
	cnt_ptr->PlayFunc = PlayLogoDemo;
	//デモタイプをロゴにする
	cnt_ptr->DemoType = DEMO_TYPE_LOGO;
	//デモ再生中にする
	cnt_ptr->DemoPlay = TRUE;

}

//----------------------------------------------------------------------------
/**
 *	@brief		ノーマルデモ生成
 *
 *	@param	*cnt_ptr		コントローラポインタ
 *	@param	* inBgl			BGL
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetupNormalDemo(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl)
{
	DEMO_TYPE type;
	ClearDemo(cnt_ptr);
	//再生するデモタイプを取得
	type = NormalDemoLoop[cnt_ptr->NormDemoCount];

	if (type == DEMO_TYPE_BATTLE){		//バトルデモ
		SetupBattleDemo(cnt_ptr, inBgl);
	}else{	//(type == DEMO_TYPE_LOGP)	ロゴデモ
		SetupLogoDemo(cnt_ptr, inBgl);
	}

	//次のデモタイプセット
	cnt_ptr->NormDemoCount = (cnt_ptr->NormDemoCount+1) % NORMAL_DEMO_LOOP;

}

//----------------------------------------------------------------------------
/**
 *	@brief	スコアデモ再生
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void PlayScoreDemo(SUB_DISP_CNT_PTR ptr)
{
	if (ptr->DemoCnt.FilledScore != ptr->DemoCnt.DispScore){
		FillScore(&ptr->DemoCnt, ptr->Bgl);
		GF_BGL_ScrPalChange( ptr->Bgl, CMN_BG, SCORE_DISP_START_X, SCORE_DISP_START_Y,
				SCORE_NUMBER_W*SCORE_DIGI_MAX, SCORE_NUMBER_H, 3 );
		GF_BGL_LoadScreenV_Req(ptr->Bgl, CMN_BG);
	}
	OS_Printf("スコアデモ中\n");
}

//----------------------------------------------------------------------------
/**
 *	@brief	落下デモ再生
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void PlayFallDemo(SUB_DISP_CNT_PTR ptr)
{
	DEMO_CONT *cnt;
	cnt = &ptr->DemoCnt;

	cnt->DemoFrame++;

	if (cnt->DemoFrame > FALL_DEMO_FRAME){
		//デモクリア
		ClearDemo(cnt);
		return;
	}

	//座標セット
	SetFallPokePos(cnt->DemoFrame, FallDemoPokePos, cnt->ActPtr[0]);

	cnt->BGOffset += FALL_SPEED;
	G2S_SetBG2Offset(0, cnt->BGOffset);
}

//----------------------------------------------------------------------------
/**
 *	@brief	バトルデモ再生
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void PlayBattleDemo(SUB_DISP_CNT_PTR ptr)
{
	DEMO_CONT *cnt;
	cnt = &ptr->DemoCnt;

	cnt->DemoFrame++;

	if (cnt->DemoFrame > BATTLE_DEMO_FRAME){
		//デモクリア
		ClearDemo(cnt);
		return;
	}

	//ＢＧエフェクト
	if (BATTLE_DEMO_FRAME1 == cnt->DemoFrame){	//出現
		//アフィンBG表示
		GF_Disp_GXS_VisibleControl( GX_PLANEMASK_BG3, VISIBLE_ON );
	}else if(BATTLE_DEMO_FRAME1+ALPHA_WAIT_SYNC < cnt->DemoFrame){
		int frame;
		u16 alpha;
		frame = cnt->DemoFrame - (BATTLE_DEMO_FRAME1+ALPHA_WAIT_SYNC);
		if (frame<=BTL_ALPHA_BLEND_SYNC){
			alpha = (frame*16)/BTL_ALPHA_BLEND_SYNC;
			//アルファブレンド
			G2S_SetBlendAlpha( GX_BLEND_PLANEMASK_BG3,
				GX_BLEND_PLANEMASK_OBJ|GX_BLEND_PLANEMASK_BG2|GX_BLEND_PLANEMASK_BD,
				16-alpha, alpha );
		}
	}

	//座標セット
	SetBtlPokePos(cnt->DemoFrame, BtlDemoPokePos1, cnt->ActPtr[0]);
	SetBtlPokePos(cnt->DemoFrame, BtlDemoPokePos2, cnt->ActPtr[1]);

}

//----------------------------------------------------------------------------
/**
 *	@brief	ロゴデモ再生
 *
 *	@param	ptr		コントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void PlayLogoDemo(SUB_DISP_CNT_PTR ptr)
{

	DEMO_CONT *cnt;
	cnt = &ptr->DemoCnt;

	cnt->DemoFrame++;

	if (cnt->DemoFrame > LOGO_DEMO_FRAME){
		//デモクリア
		ClearDemo(cnt);
		return;
	}

	if (cnt->DemoFrame == LOGO_DEMO_FRAME1+1){
		PkthlnClAct_SetActive(cnt->LogoEffActPtr, TRUE, TRUE);
	}else if(cnt->DemoFrame == LOGO_DEMO_FRAME1+LOGO_DEMO_FRAME2+1){
		PkthlnClAct_SetActive(cnt->LogoEffActPtr, TRUE, FALSE);
	}

	if (cnt->DemoFrame <= LOGO_DEMO_FRAME1){
		MtxFx22 mtx;
		fx32 scale;
		float val;

		val = ((float)cnt->DemoFrame)/LOGO_DEMO_FRAME1;

		scale = FX32_ONE * val;
		mtx._00 = scale;
		mtx._01 = 0;
		mtx._10 = 0;
		mtx._11 = scale;

		SVC_WaitVBlankIntr();          // Waiting the end of VBlank interrup
		GF_BGL_AffineSet( ptr->Bgl, AFF_BG, &mtx, 128, 96 );
	}else if( (LOGO_DEMO_FRAME1<cnt->DemoFrame)&&
			(cnt->DemoFrame <= LOGO_DEMO_FRAME1+LOGO_DEMO_FRAME2)){
		int frame;
		int x;
		frame = cnt->DemoFrame - LOGO_DEMO_FRAME1;
		//エフェクト移動
		x = LOGO_EFF_START_X + ((LOGO_EFF_MOVE_LEN * frame) / LOGO_DEMO_FRAME2);
		{
			CLACT_WORK_PTR act_ptr;
			VecFx32 vec;
			vec.z = 0;
			vec.x = x * FX32_ONE;
			vec.y = SUB_DISP_DISTANCE+(LOGO_EFF_START_Y*FX32_ONE);
			act_ptr = PkthlnClAct_GetClActWorkPtr(cnt->LogoEffActPtr);
			CLACT_SetMatrix( act_ptr, &vec );
		}
	}else{
		int frame;
		u16 alpha;
		//エフェクトアクター非表示
		PkthlnClAct_SetActive(cnt->LogoEffActPtr, TRUE, FALSE);
		frame = cnt->DemoFrame - (LOGO_DEMO_FRAME1+LOGO_DEMO_FRAME2);
		alpha = (frame*16)/LOGO_DEMO_FRAME3;
		//アルファブレンド
		G2S_SetBlendAlpha( GX_BLEND_PLANEMASK_BG3,
			GX_BLEND_PLANEMASK_BG2|GX_BLEND_PLANEMASK_BD, 16-alpha, alpha );
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief	戦闘デモポケのセットアップ
 *
 *	@param	*cnt_ptr		デモコントローラポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetupBtlDemoPoke(DEMO_CONT *cnt_ptr)
{
	u8 i;
	int netID1, netID2;
	int poke1,poke2;
	//デモに出すポケの所有者を決定
	netID1 = gf_rand()%ENTRY_MEMBER_NUM_MAX;
	for (i=0;i<RND_TRIAL_MAX;i++){
		netID2 = gf_rand()%ENTRY_MEMBER_NUM_MAX;
		if (netID1 != netID2){
			break;
		}
	}
	if (i == RND_TRIAL_MAX){
		netID2 = (netID1+1)%ENTRY_MEMBER_NUM_MAX;
	}
	//デモポケの決定
	poke1 = (netID1 * ENTRY_MAX) + (gf_rand()%ENTRY_MAX);
	poke2 = (netID2 * ENTRY_MAX) + (gf_rand()%ENTRY_MAX);

	//転送
	TransPokeGra(cnt_ptr, 0, poke1);
	TransPokeGra(cnt_ptr, 1, poke2);

	//座標セット
	{
		CLACT_WORK_PTR act_ptr;
		VecFx32 vec;
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt_ptr->ActPtr[0]);
		vec = BtlDemoPokePos1[0];
		vec.y += SUB_DISP_DISTANCE;
		CLACT_SetMatrix( act_ptr, &vec );
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt_ptr->ActPtr[1]);
		vec = BtlDemoPokePos2[0];
		vec.y += SUB_DISP_DISTANCE;
		CLACT_SetMatrix( act_ptr, &vec );
	}
	//表示
	PkthlnClAct_SetActive(cnt_ptr->ActPtr[0], 1, 1);
	PkthlnClAct_SetActive(cnt_ptr->ActPtr[1], 1, 1);
}

//----------------------------------------------------------------------------
/**
 *	@brief	戦闘デモポケの位置セット
 *
 *	@param	inFrame			デモフレーム
 *	@param	*inPosList		位置リスト
 *	@param	actPtr			アクターポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetBtlPokePos(const u8 inFrame, const VecFx32 *inPosList, PKTHLN_ACT_PTR actPtr)
{
	fx32 dif_x, dif_y, new_x, new_y;

	if ( inFrame<=BATTLE_DEMO_FRAME1 ){
		//差分計算
		dif_x = inPosList[1].x - inPosList[0].x;
		dif_y = inPosList[1].y - inPosList[0].y;
		new_x = inPosList[0].x + (dif_x * inFrame)/BATTLE_DEMO_FRAME1;
		new_y = inPosList[0].y + (dif_y * inFrame)/BATTLE_DEMO_FRAME1;
	}else if( (BATTLE_DEMO_FRAME1<inFrame)&&(inFrame<=(BATTLE_DEMO_FRAME1+BATTLE_DEMO_FRAME2)) ){
		u8 frame;
		frame = inFrame - (BATTLE_DEMO_FRAME1);
		//差分計算
		dif_x = inPosList[2].x - inPosList[1].x;
		dif_y = inPosList[2].y - inPosList[1].y;
		new_x = inPosList[1].x + (dif_x * frame)/BATTLE_DEMO_FRAME2;
		new_y = inPosList[1].y + (dif_y * frame)/BATTLE_DEMO_FRAME2;
	}else{
		u8 frame;
		frame = inFrame - (BATTLE_DEMO_FRAME1+BATTLE_DEMO_FRAME2);
		//差分計算
		dif_x = inPosList[3].x - inPosList[2].x;
		dif_y = inPosList[3].y - inPosList[2].y;
		OS_Printf("frame = %d:def = %d\n",frame,dif_y);
		new_x = inPosList[2].x + (dif_x * frame)/BATTLE_DEMO_FRAME3;
		new_y = inPosList[2].y + (dif_y * frame)/BATTLE_DEMO_FRAME3;
	}

	//座標セット
	{
		CLACT_WORK_PTR act_ptr;
		VecFx32 vec;
		act_ptr = PkthlnClAct_GetClActWorkPtr(actPtr);
		vec.x = new_x;
		vec.y = SUB_DISP_DISTANCE + new_y;
		vec.z = 0;
		CLACT_SetMatrix( act_ptr, &vec );
	}

}

//----------------------------------------------------------------------------
/**
 *	@brief		落下デモセットアップ
 *
 *	@param	*cnt_ptr		デモコントローラポインタ
 *	@param	inIdx			対象ポケインデックス
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetupFallPoke(DEMO_CONT *cnt_ptr, const u8 inIdx)
{
	//転送
	TransPokeGra(cnt_ptr, 0, inIdx);

	//座標セット
	{
		CLACT_WORK_PTR act_ptr;
		VecFx32 vec;
		act_ptr = PkthlnClAct_GetClActWorkPtr(cnt_ptr->ActPtr[0]);
		vec.x = FALL_POKE_POS_X;
		vec.y = SUB_DISP_DISTANCE + FallDemoPokePos[0];
		vec.z = 0;
		CLACT_SetMatrix( act_ptr, &vec );
	}
	//表示
	PkthlnClAct_SetActive(cnt_ptr->ActPtr[0], 1, 1);
}

//----------------------------------------------------------------------------
/**
 *	@brief	落下デモポケの位置セット
 *
 *	@param	inFrame			デモフレーム
 *	@param	*inPosList		位置リスト
 *	@param	actPtr			アクターポインタ
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void SetFallPokePos(const u8 inFrame, const fx32 *inPosList, PKTHLN_ACT_PTR actPtr)
{
	fx32 dif_y, new_y;

	if ( inFrame<=FALL_DEMO_FRAME1 ){
		//差分計算
		dif_y = inPosList[1] - inPosList[0];
		new_y = inPosList[0] + (dif_y * inFrame)/FALL_DEMO_FRAME1;
	}else if( (FALL_DEMO_FRAME1<inFrame)&&(inFrame<=(FALL_DEMO_FRAME1+FALL_DEMO_FRAME2)) ){
		new_y = inPosList[1];
	}else{
		u8 frame;
		frame = inFrame - (FALL_DEMO_FRAME1+FALL_DEMO_FRAME2);
		//差分計算
		dif_y = inPosList[2] - inPosList[1];
		new_y = inPosList[1] + (dif_y * frame)/FALL_DEMO_FRAME3;
	}

	//座標セット
	{
		CLACT_WORK_PTR act_ptr;
		VecFx32 vec;
		act_ptr = PkthlnClAct_GetClActWorkPtr(actPtr);
		vec.x = FALL_POKE_POS_X;
		vec.y = SUB_DISP_DISTANCE + new_y;
		vec.z = 0;
		CLACT_SetMatrix( act_ptr, &vec );
	}
}

//----------------------------------------------------------------------------
/**
 *	@brief	スコアフィル
 *
 *	@param	cnt_ptr			デモコントローラポインタ
 *	@param	*inBgl			BGL
 *
 *	@return	none
 */
//-----------------------------------------------------------------------------
static void FillScore(DEMO_CONT *cnt_ptr, GF_BGL_INI * inBgl)
{
	u8 i;
	u8 h,t,o;
	u8 read_x[SCORE_DIGI_MAX];
	u8 read_y[SCORE_DIGI_MAX];

	//3桁の得点を3つに分解
	h = cnt_ptr->DispScore/100;
	t = (cnt_ptr->DispScore/10)-(h*10);
	o = cnt_ptr->DispScore%10;
	//データ読み込み位置を算出(数字スクリーンデータに依存)
	read_x[0] = (h%NUMBER_SCR_NUM_W)*SCORE_NUMBER_W;
	read_y[0] = (h/NUMBER_SCR_NUM_W)*SCORE_NUMBER_H;
	read_x[1] = (t%NUMBER_SCR_NUM_W)*SCORE_NUMBER_W;
	read_y[1] = (t/NUMBER_SCR_NUM_W)*SCORE_NUMBER_H;
	read_x[2] = (o%NUMBER_SCR_NUM_W)*SCORE_NUMBER_W;
	read_y[2] = (o/NUMBER_SCR_NUM_W)*SCORE_NUMBER_H;
/**
	OS_Printf("%d,%d,%d::(%d,%d),(%d,%d),(%d,%d)",h,t,o,
			read_x[0],read_y[0],
			read_x[1],read_y[1],
			read_x[2],read_y[2]);
*/
	for (i=0;i<SCORE_DIGI_MAX;i++){
/**
		GF_BGL_ScrWriteExpand( inBgl, CMN_BG,
				SCORE_DISP_START_X+(i*SCORE_NUMBER_W), SCORE_DISP_START_Y,
				SCORE_NUMBER_W, SCORE_NUMBER_H,
				&cnt_ptr->PointScrnData->rawData,
				read_x[i], read_y[i], SCORE_NUMBER_W, SCORE_NUMBER_H );
*/
		GF_BGL_ScrWriteFree(inBgl, CMN_BG,
				SCORE_DISP_START_X+(i*SCORE_NUMBER_W), SCORE_DISP_START_Y,
				SCORE_NUMBER_W, SCORE_NUMBER_H,
				&cnt_ptr->PointScrnData->rawData,
				read_x[i], read_y[i], SCORE_NUMBER_W*NUMBER_SCR_NUM_W, SCORE_NUMBER_H*NUMBER_SCR_NUM_H );
	}

	cnt_ptr->FilledScore = cnt_ptr->DispScore;
}

//----------------------------------------------------------------------------
/**
 *	@brief	スクリーンデータの再作成
 *
 *	@param	inOfs		足しこむキャラオフセット
 *	@param	*ioScrnData	スクリーンデータ
 *
 *	@return none
 */
//-----------------------------------------------------------------------------
static void ReMakeScreenData(const inOfs, NNSG2dScreenData *ioScrnData)
{
	int i;
	u16 *data;
	u16 *one_data;

	u16 chr_data;
	u8 pal_data;
	u16 chr_size;

	chr_size = ioScrnData->szByte / sizeof(u16);

	data = (u16*)ioScrnData->rawData;
	for(i=0;i<chr_size;i++){
		one_data = &data[i];
		//キャラデータ取得
		chr_data = (*one_data) & 0xfff;
		pal_data = (*one_data) - chr_data;
		//オフセット分足しこむ
		chr_data += inOfs;
		//データに戻す
		data[i] = pal_data + chr_data;
	}
}